home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / wais / waisgate / docid.c < prev    next >
C/C++ Source or Header  |  1995-05-09  |  11KB  |  375 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.
  4.  *
  5.  * these are the methods for the DocID struct
  6.  * -brewster
  7.  *
  8.  * $Log:    docid.c,v $
  9.  * Revision 1.6  92/05/10  14:42:57  jonathan
  10.  * Made a little safer on NULL docid's and such.
  11.  * 
  12.  * Revision 1.5  92/04/01  17:07:25  jonathan
  13.  * Added copyDocID.
  14.  * 
  15.  * Revision 1.4  92/02/21  11:05:03  jonathan
  16.  * added RCSIdent
  17.  * 
  18.  * Revision 1.3  92/02/21  11:04:30  jonathan
  19.  * Added header, fixed $Log.
  20.  * 
  21.  * Revision 1.2  92/02/12  13:17:44  jonathan
  22.  * Added $Log so RCS will put the log message in the header
  23.  * 
  24. */
  25.  
  26. #ifndef lint
  27. static char *RCSid = "$Header: /tmp_mnt/net/quake/proj/wais/wais-8-b5/ir/RCS/docid.c,v 1.6 92/05/10 14:42:57 jonathan Exp $";
  28. #endif
  29.  
  30. #include <ctype.h>
  31. #include "docid.h"
  32. #include "irfileio.h"
  33. #include "cutil.h"
  34. #include "cdialect.h"
  35.  
  36. #define TESTDOC(doc) if((doc) == NULL) return NULL
  37.  
  38. /*---------------------------------------------------------------------------*/
  39.  
  40. /* get the server slot */
  41. any* GetServer(doc)
  42. DocID* doc;
  43. {
  44.   TESTDOC(doc);
  45.   if(NULL != doc->distributorServer)
  46.     return(doc->distributorServer);
  47.   else return(doc->originalServer);
  48. }
  49.  
  50. /*---------------------------------------------------------------------------*/
  51.  
  52. any* GetDatabase(doc)
  53. DocID* doc;
  54. {
  55.   TESTDOC(doc);
  56.   if(NULL != doc->distributorDatabase)
  57.     return(doc->distributorDatabase);
  58.   else return(doc->originalDatabase);
  59. }
  60.  
  61. /*---------------------------------------------------------------------------*/
  62.  
  63. any* GetLocalID(doc)
  64. DocID* doc;
  65. {
  66.   TESTDOC(doc);
  67.   if(NULL != doc->distributorLocalID)
  68.     return(doc->distributorLocalID);
  69.   else return(doc->originalLocalID);
  70. }
  71.  
  72. /*---------------------------------------------------------------------------*/
  73.  
  74. long GetCopyrightDisposition(doc)
  75. DocID* doc;
  76. {
  77.   if(doc)
  78.     return(doc->copyrightDisposition);
  79.   else return 0;
  80. }
  81.  
  82. /*---------------------------------------------------------------------------*/
  83.  
  84. /* returns FALSE if it loses, TRUE if it wins */
  85. long ReadDocID(doc,file)
  86. DocID* doc;
  87. FILE* file;
  88. {
  89.   char temp_string[MAX_SYMBOL_SIZE];
  90.   if(FALSE == CheckStartOfStruct("doc-id", file)){
  91.     return(FALSE);
  92.   }
  93.   doc->originalServer = NULL;
  94.   doc->originalDatabase = NULL;
  95.   doc->originalLocalID = NULL;
  96.   doc->distributorServer = NULL;
  97.   doc->distributorDatabase = NULL;
  98.   doc->distributorLocalID = NULL;
  99.   doc->copyrightDisposition = COPY_WITHOUT_RESTRICTION;
  100.     
  101.   while(TRUE){
  102.     long result = ReadSymbol(temp_string, file, 
  103.                  (long)MAX_SYMBOL_SIZE);
  104.         
  105.     if(FALSE == result){ 
  106.       return(FALSE);
  107.     }
  108.     if(END_OF_STRUCT_OR_LIST == result){
  109.       break;
  110.     }
  111.     if(0 == strcmp(temp_string, ":original-server")){
  112.       any* an_any = (any*)s_malloc(sizeof(any));
  113.       ReadAny(an_any, file);
  114.       doc->originalServer = an_any;
  115.     }
  116.     else if(0 == strcmp(temp_string, ":original-database")){
  117.       any* an_any = (any*)s_malloc(sizeof(any));
  118.       ReadAny(an_any, file);
  119.       doc->originalDatabase = an_any;
  120.     }
  121.     else if(0 == strcmp(temp_string, ":original-local-id")){
  122.       any* an_any = (any*)s_malloc(sizeof(any));
  123.       ReadAny(an_any, file);
  124.       doc->originalLocalID = an_any;
  125.     }
  126.     else if(0 == strcmp(temp_string, ":distributor-server")){
  127.       any* an_any = (any*)s_malloc(sizeof(any));
  128.       ReadAny(an_any, file);
  129.       doc->distributorServer = an_any;
  130.     }
  131.     else if(0 == strcmp(temp_string, ":distributor-database")){
  132.       any* an_any = (any*)s_malloc(sizeof(any));
  133.       ReadAny(an_any, file);
  134.       doc->distributorDatabase = an_any;
  135.     }
  136.     else if(0 == strcmp(temp_string, ":distributor-local-id")){
  137.       any* an_any = (any*)s_malloc(sizeof(any));
  138.       ReadAny(an_any, file);
  139.       doc->distributorLocalID = an_any;
  140.     }
  141.     else if(0 == strcmp(temp_string, ":copyright-disposition"))
  142.       ReadLong(file,&doc->copyrightDisposition);
  143.     else{
  144.       SkipObject(file);
  145.     }
  146.   }
  147.   return(TRUE);
  148. }
  149.  
  150.  
  151. /*---------------------------------------------------------------------------*/
  152.  
  153. /* this writes a CDocID to a stream */
  154. long WriteDocID(doc,file)
  155. DocID* doc;
  156. FILE* file;
  157. {
  158.   WriteNewline(file);
  159.   WriteStartOfStruct("doc-id", file);
  160.   if (NULL != doc->originalServer){
  161.     WriteNewline(file);
  162.     WriteSymbol(":original-server", file); WriteAny(doc->originalServer, file);
  163.   }
  164.   if (NULL != doc->originalDatabase){
  165.     WriteNewline(file);
  166.     WriteSymbol(":original-database", file); WriteAny(doc->originalDatabase, file);
  167.   }
  168.   if (NULL != doc->originalLocalID){
  169.     WriteNewline(file);
  170.     WriteSymbol(":original-local-id", file); WriteAny(doc->originalLocalID, file);
  171.   }
  172.   if (NULL != doc->distributorServer){
  173.     WriteNewline(file);
  174.     WriteSymbol(":distributor-server", file); WriteAny(doc->distributorServer, file);
  175.   }
  176.   if (NULL != doc->distributorDatabase){
  177.     WriteNewline(file);
  178.     WriteSymbol(":distributor-database", file); 
  179.     WriteAny(doc->distributorDatabase, file);
  180.   }
  181.   if (NULL != doc->distributorLocalID){
  182.     WriteNewline(file);
  183.     WriteSymbol(":distributor-local-id", file); 
  184.     WriteAny(doc->distributorLocalID, file);
  185.   }
  186.   WriteNewline(file);
  187.   WriteSymbol(":copyright-disposition", file);
  188.   WriteLong(doc->copyrightDisposition, file);
  189.   return(WriteEndOfStruct(file));
  190. }
  191.  
  192. /*---------------------------------------------------------------------------*/
  193.  
  194.     static Boolean safeCmp _AP((any* a1,any* a2));
  195.  
  196.     static Boolean safeCmp(a1,a2)
  197.         any* a1;
  198.         any* a2;
  199.         {
  200.         /* compare 2 any's, either of which may be NULL */
  201.         if (a1 == NULL && a2 == NULL)
  202.               return(true);
  203.         else if (a1 == NULL || a2 == NULL)
  204.               return(false);
  205.         else if (a1->size != a2->size)
  206.               return(false);
  207.         else if (memcmp(a1->bytes,a2->bytes,(size_t)a1->size) == 0)
  208.               return(true);
  209.         else
  210.             return(false);
  211.         }
  212.  
  213. /*---------------------------------------------------------------------------*/
  214.  
  215. Boolean cmpDocIDs(d1,d2)
  216. DocID* d1;
  217. DocID* d2;
  218. {
  219.   if (safeCmp(d1->originalServer,d2->originalServer) &&
  220.       safeCmp(d1->originalDatabase,d2->originalDatabase) &&
  221.       safeCmp(d1->originalLocalID,d2->originalLocalID) &&
  222.       safeCmp(d1->distributorServer,d2->distributorServer) &&
  223.       safeCmp(d1->distributorDatabase,d2->distributorDatabase) &&
  224.       safeCmp(d1->distributorLocalID,d2->distributorLocalID) &&
  225.       d1->copyrightDisposition == d2->copyrightDisposition)
  226.     return(true);
  227.   else
  228.     return(false); 
  229. }
  230.     
  231. /*---------------------------------------------------------------------------*/
  232.  
  233. DocID* 
  234. makeDocID()
  235. {
  236.   return((DocID*)s_malloc((size_t)sizeof(DocID)));
  237. }
  238.  
  239. /*---------------------------------------------------------------------------*/
  240.  
  241. DocID*
  242. copyDocID(doc)
  243. DocID* doc;
  244. {
  245.   DocID* result = NULL;
  246.   if(doc != NULL && 
  247.      (result = makeDocID()) != NULL) {
  248.     result->originalServer = duplicateAny(doc->originalServer);
  249.     result->originalDatabase = duplicateAny(doc->originalDatabase);
  250.     result->originalLocalID = duplicateAny(doc->originalLocalID);
  251.     result->distributorServer = duplicateAny(doc->distributorServer);
  252.     result->distributorDatabase = duplicateAny(doc->distributorDatabase);
  253.     result->distributorLocalID = duplicateAny(doc->distributorLocalID);
  254.   }
  255.   return result;
  256. }
  257.  
  258. /*---------------------------------------------------------------------------*/
  259.  
  260. void freeDocID(doc)
  261. DocID* doc;
  262. {
  263.   if(doc) {
  264.     freeAny(doc->originalServer);
  265.     freeAny(doc->originalDatabase);
  266.     freeAny(doc->originalLocalID);
  267.     freeAny(doc->distributorServer);
  268.     freeAny(doc->distributorDatabase);
  269.     freeAny(doc->distributorLocalID);
  270.     s_free(doc);
  271.   }
  272. }
  273.  
  274. /*---------------------------------------------------------------------------*/
  275.  
  276. #define DT_OriginalServer     (data_tag)1
  277. #define DT_OriginalDatabase     (data_tag)2
  278. #define DT_OriginalLocalID    (data_tag)3
  279. #define DT_DistributorServer    (data_tag)4
  280. #define DT_DistributorDatabase    (data_tag)5
  281. #define DT_DistributorLocalID    (data_tag)6
  282. #define DT_CopyrightDispostion    (data_tag)7
  283.  
  284. DocID*
  285. docIDFromAny(rawDocID)
  286. any* rawDocID;
  287. /* read from a z3950 docid to a docid structure */
  288. {
  289.   DocID* docID;
  290.   char* buf;
  291.   
  292.   TESTDOC(rawDocID);
  293.  
  294.   buf = rawDocID->bytes;
  295.   docID = makeDocID();
  296.   while ((buf - rawDocID->bytes) < rawDocID->size)
  297.     { data_tag tag = peekTag(buf);
  298.       switch (tag)
  299.     { case DT_OriginalServer:
  300.         buf = readAny(&(docID->originalServer),buf);
  301.         break;
  302.       case DT_OriginalDatabase:
  303.         buf = readAny(&(docID->originalDatabase),buf);
  304.         break;
  305.       case DT_OriginalLocalID:
  306.         buf = readAny(&(docID->originalLocalID),buf);
  307.         break;
  308.       case DT_DistributorServer:
  309.         buf = readAny(&(docID->distributorServer),buf);
  310.         break;
  311.       case DT_DistributorDatabase:
  312.         buf = readAny(&(docID->distributorDatabase),buf);
  313.         break;
  314.       case DT_DistributorLocalID:
  315.         buf = readAny(&(docID->distributorLocalID),buf);
  316.         break;
  317.       case DT_CopyrightDispostion:
  318.         buf = readNum(&(docID->copyrightDisposition),buf);
  319.         break;
  320.       default:
  321.         freeDocID(docID);
  322.         return(NULL);
  323.       };
  324.     }
  325.   
  326.   return(docID);
  327. }
  328.  
  329. /*---------------------------------------------------------------------------*/
  330.  
  331. any*
  332. anyFromDocID(docID)
  333. DocID* docID;
  334. /* write a docid structure to a buffer in z3950 format */
  335. {
  336.   any* rawDocID = NULL;
  337.   char* buf = NULL;
  338.   char* data = NULL;
  339.   long size,bytesLeft;
  340.   
  341.   if (docID == NULL)
  342.     return(NULL);
  343.     
  344.   size = writtenAnySize(DT_OriginalServer,docID->originalServer);
  345.   size += writtenAnySize(DT_OriginalDatabase,docID->originalDatabase);
  346.   size += writtenAnySize(DT_OriginalLocalID,docID->originalLocalID);
  347.   size += writtenAnySize(DT_DistributorServer,docID->distributorServer);
  348.   size += writtenAnySize(DT_DistributorDatabase,docID->distributorDatabase);
  349.   size += writtenAnySize(DT_DistributorLocalID,docID->distributorLocalID);
  350.   size += writtenNumSize(DT_CopyrightDispostion,docID->copyrightDisposition);
  351.   
  352.   data = s_malloc((size_t)(sizeof(char) * size));
  353.   
  354.   buf = data;
  355.   bytesLeft = size;
  356.   
  357.   buf = writeAny(docID->originalServer,DT_OriginalServer,buf,&bytesLeft);
  358.   buf = writeAny(docID->originalDatabase,DT_OriginalDatabase,buf,&bytesLeft);
  359.   buf = writeAny(docID->originalLocalID,DT_OriginalLocalID,buf,&bytesLeft);
  360.   buf = writeAny(docID->distributorServer,DT_DistributorServer,buf,
  361.                  &bytesLeft);
  362.   buf = writeAny(docID->distributorDatabase,DT_DistributorDatabase,
  363.                  buf,&bytesLeft);
  364.   buf = writeAny(docID->distributorLocalID,DT_DistributorLocalID,buf,
  365.                  &bytesLeft);
  366.   buf = writeNum(docID->copyrightDisposition,DT_CopyrightDispostion,
  367.                  buf,&bytesLeft);
  368.   
  369.   rawDocID = makeAny(size,data);
  370.   
  371.   return(rawDocID);
  372. }
  373.  
  374. /*---------------------------------------------------------------------------*/
  375.